package output;

import instance.InstanceEj3;

import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Vector;


public class Problem3Output implements Output{
 
	private static String outputFile;
	private LinkedList<LinkedList<Integer>> solutions;
	
	
	public Problem3Output(LinkedList<LinkedList<Integer>> solutions2) {
		this.solutions = solutions2;
	}
	public Problem3Output(String nombArch){
		
	  outputFile =nombArch;
	}
	public void writeTestRend(LinkedList<String> strings_salida) throws Exception {
		/*||CUIDADO||:Usar después de generar el tipo Problem3Output con el constructor que cambia el outputfile*/
		BufferedWriter bw = new BufferedWriter(new PrintWriter(
				Problem3Output.outputFile));
		
		Iterator<String> it_res = strings_salida.iterator();
		while(it_res.hasNext()){
			String st = it_res.next();
			bw.write(st);
			if(it_res.hasNext()) bw.newLine();
		}
		bw.close();
	}
	
	@Override
	public void writeFile(String outputFile) throws Exception {
		// TODO Auto-generated method stub

		Problem3Output.outputFile = outputFile;

		BufferedWriter bufferedWriter = new BufferedWriter(new PrintWriter(
				Problem3Output.outputFile));

		// Escribimos todas las soluciones.
		//Aclaraci�n: en el enunciado dice que por cada instancia se escribe una linea con la solucion, 
		//es decir las posiciones de las piedras para llegar de x a y
		//pero en el archivo de salida presentado por la catedra hay una linea con el camino a seguir para llegar a cada x y de cada instancia de entrada.
		//Por lo tanto se decidio respetar al escritura siguiendo el modelo de este archivo.
		
		for (int i = 0; i < solutions.size(); i++) {
			String linea = " ";
			// Por cada soluci�n.
			LinkedList<Integer> solution =  solutions.get(i);

			printSolution(bufferedWriter, solution,linea);
		}

		bufferedWriter.close();
	}

	// Imprime una soluci�n en el archivo de salida.
	private void printSolution(BufferedWriter bw,LinkedList<Integer> solution, String linea) throws Exception {
		if (solution.isEmpty())bw.write(" ");
		
		for (int i = 0; i< solution.size();i++){
		if (i ==0){	linea=String.valueOf(solution.get(i));
		}else{
		linea =linea.concat(" ");
		linea =linea.concat(String.valueOf(solution.get(i)));
		

		}
		}
		bw.write(linea);
        bw.newLine();	

	
		}
	public static void deListaAArchivo(LinkedList<InstanceEj3> lista, String nombArch)throws Exception{
		BufferedWriter bw = new BufferedWriter(new PrintWriter(nombArch));
		
		Iterator<InstanceEj3> it = lista.iterator();
		while(it.hasNext()){
			InstanceEj3 inst = it.next();
			
			String p_y_q = String.valueOf(inst.getp()) + " " +String.valueOf(inst.getq());
			bw.write(p_y_q);
	        bw.newLine();
	        Vector<Integer> piedras = inst.getPiedras();
	        String vector = "";
			for(int i=0; i < piedras.size(); i++){
				vector = vector.concat(String.valueOf(piedras.elementAt(i)));
				if(i!=piedras.size()-1) vector = vector.concat(" ");
			}
			bw.write(vector);
	        bw.newLine();
	        LinkedList<Integer> Xs_e_Ys = inst.getPares();
	        Iterator<Integer> it_Xs_e_Ys = Xs_e_Ys.iterator();
	        String pares = "";
	        while(it_Xs_e_Ys.hasNext()){
	        	Integer X = it_Xs_e_Ys.next();
	        	Integer Y = it_Xs_e_Ys.next();
	        	pares = pares.concat(String.valueOf(X) + " " +String.valueOf(Y));
	        	if(it_Xs_e_Ys.hasNext())pares = pares.concat(";");
	        }
	        bw.write(pares);
	        if(it.hasNext())bw.newLine();
		}    

	    bw.close();
	}
}
	
